# 17. 初识函数

# 什么是函数

函数可以定义封装一个事情或者功能，等到需要的时候直接拿去用

函数：对代码块和功能的封装和定义

def so():
    print("你好")
    print("我好")
so()
so()

执行结果：
你好
我好
你好
我好

以上实例，创建一个函数，并调用这函数二次

# 函数的定义

使用def关键字来定义函数

函数名的命名规则跟变量的命名规则基本一样

函数体：就是函数被执行后所需要执行的代码

函数的语法格式：

def 函数名():
    函数体

# 函数的注释

def chi(food, drink): 
    """    
    这里是函数的注释 , 先写一下当前这个函数是干什么的 , ⽐比如我这个函数就是一个吃    
    :param :param food: 参数 food 是什么意思    
    :param :param drink: 参数 drink 是什么意思    
    :return :return: 返回的是什么东东    
    """   
    print(food, drink)    
    return "very good"

# 函数的调用

函数的调用：使用函数名可以调用函数

格式：函数名()

这里创建一个实例，随便来个：时间表

def time():
    print("8点起床，收拾，吃早餐")
    print("9点半坐车，去上班")
    print("12点午休时间，吃饭，午休")
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃饭休息")
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
time()

执行结果：
8点起床，收拾，吃早餐
9点半坐车，去上班
12点午休时间，吃饭，午休
14点上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃饭休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到

# 函数的调用过程

def time(): #1  #3
    print("8点起床，收拾，吃早餐") #4
    print("9点半坐车，去上班") #5
    print("12点午休时间，吃饭，午休") #6
    print("14点，上班时间") #7
    print("18点下班时间，收拾东西下班，坐车回家") #8
    print("18点半去集市买菜") #9
    print("19点到家煮饭") #10
    print("20点吃饭休息") #11
    print("21点半洗澡准备回房间休息") #12
    print("22点到房间看会书") #13
    print("23点半睡觉时间到")  #14
time() #2  #15

执行过程：
1. 定义函数time()
2. 调用函数time()
3. 执行函数time()
4. 打印：8点起床，收拾，吃早餐
5. 打印：9点半坐车，去上班
6. 打印：12点午休时间，吃饭，午休
7. 打印：14点上班时间
8. 打印：18点下班时间，收拾东西下班，坐车回家
9. 打印：18点半去集市买菜
10. 打印：19点到家煮饭
11. 打印：20点吃饭休息
12. 打印：21点半洗澡准备回房间休息
13. 打印：22点到房间看会书
14. 打印：23点半睡觉时间到
15. 函数执行完毕，本次调用结果time()

# 函数的返回值

执行完函数之后，可以使用return来返回结果

一旦函数执行到return，就不再执行下面的函数

格式：

函数定义时：return 值
调用函数时：变量 = 函数()

# 给函数的调用者返回值

def time():
    print("8点起床，收拾，吃早餐")
    print("9点半坐车，去上班")
    print("12点午休时间，吃饭，午休")
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃饭休息")
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
    return "每天的行程"
so = time()
print(so)

执行结果：
8点起床，收拾，吃早餐
9点半坐车，去上班
12点午休时间，吃饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃饭休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到
每天的行程

或许有这种困惑，只是调用函数的返回值，那为什么会输出函数的执行过程，因为函数在赋值给变量的时候，会将自身执行一遍在把返回值返回到变量中，这样就造成了变量中的值是函数的执行过程加返回值，实际变量中的值只是返回值

def time():
    print("8点起床，收拾，吃早餐")
    print("9点半坐车，去上班")
    print("12点午休时间，吃饭，午休")
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃饭休息")
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
    return "每天的行程"
so = time()
print("变量中的值只是函数的返回值")
print(so)

执行结果：
8点起床，收拾，吃早餐
9点半坐车，去上班
12点午休时间，吃饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃饭休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到
变量中的值只是函数的返回值
每天的行程

# 函数执行到return，就会结束

如果函数在执行过程中遇到了return，就会到此为止，不会执行下面的代码块

def time():
    print("8点起床，收拾，吃早餐")
    print("9点半坐车，去上班")
    print("12点午休时间，吃饭，午休")
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃饭休息")
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
    return "每天的行程"
    print("我是不会被执行到")
so = time()
print(so)

执行结果：
8点起床，收拾，吃早餐
9点半坐车，去上班
12点午休时间，吃饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃饭休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到
每天的行程

# 函数的返回值可以有多个结果

理论上，函数是可以拥有无限的返回结果值

函数的返回值如果超过1个或多个，多个值需要用 , 逗号隔开，会以元组类型表示

def time():
    print("8点起床，收拾，吃早餐")
    print("9点半坐车，去上班")
    print("12点午休时间，吃饭，午休")
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃饭休息")
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
    return "每天的行程","请较准时的按时间表生活"
so = time()
print(so)

执行结果：
8点起床，收拾，吃早餐
9点半坐车，去上班
12点午休时间，吃饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃饭休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到
('每天的行程', '请较准时的按时间表生活')

# 函数返回值总结

如果函数执行过程中遇到return，函数执行到至结束，往后的代码块不会执行
return 返回值
1. 如果return 什么都不写或者不写return，那么系统默认会帮你写，返回值为：None
2. 如果return 返回值写一个值，那么调用者可以接收一个结果
3. 如果retrun 返回值写了多个值，多个值需要用 , 逗号隔开，那么调用者可以接收到一个tuple元组类型的数据，调用都也可以直接解构成多少变量

# 函数的参数

可以通过函数的参数向函数传递一些信息

参数，函数在调用的时候指定具体的一个变量的值，这就是参数

形参：写在函数声明的位置的变量叫形参，形式上的一个完整，表示函数需要接收值
实参：在函数调用的时候给函数传递的值，叫实参，实际执行的时候给函数传递的信息，表示给函数传输数据
传参：给函数传递信息的时候将实际参数(实参)交给形式参数(形参)的过程被称为传参

函数的参数个数是没有要求的但是,在运行的时候. 形参和实参要匹配

语法格式：

函数定义时：def 函数(变量名)
调用函数时：函数(传递的数据)

def time(name): #形参
    print("8点起床，收拾，吃%s" % name)
    print("9点半坐车，去上班")
    print("12点午休时间，吃饭，午休")
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃饭休息")
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
time("小米粥") #实参

执行结果：
8点起床，收拾，吃小米粥
9点半坐车，去上班
12点午休时间，吃饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃饭休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到

# 函数的参数－实参

位置参数：按照位置的顺序将值分别赋值到函数中，在传参的过程中，系统会默认按照位置把实参赋值到形参
关键字参数：关键字参数，不需要按照位置顺序来写实参，只需要记住形参的名字就可以
混合参数：可以把位置参数跟关键字参数混合着用，也就是说在调用函数的时候可以给出位置参数，也可以指定关键字函数，关键字参数必须在位置参数后面

# 位置参数

按照位置的顺序将值分别赋值到函数中，在传参的过程中，系统会默认按照位置把实参赋值到形参

def time(ant,lun,din):
    print("8点起床，收拾，吃%s" % ant)
    print("9点半坐车，去上班")
    print("12点午休时间，吃%s，午休" % lun)
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃%s ,休息" % din)
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
time("小米粥","烧肉饭","糖醋排骨，空心菜")

执行结果：
8点起床，收拾，吃小米粥
9点半坐车，去上班
12点午休时间，吃烧肉饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃糖醋排骨，空心菜 ,休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到

以上实例，在访问time()，按照位置的顺序分别把写好的几个值赋值到函数中的形参中

# 实例：编写函数，传递二个值对比

编写函数，给函数传递二个参数，并进行对比，返回大的值

def comp(a,b):
    if a > b:
        return a
    return b
so = comp(15,12)
print(so)

执行结果：
15

# 关键字参数

关键字参数，不需要按照位置顺序来写实参，只需要记住形参的名字就可以

def time(ant,lun,din):
    print("8点起床，收拾，吃%s" % ant)
    print("9点半坐车，去上班")
    print("12点午休时间，吃%s，午休" % lun)
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃%s ,休息" % din)
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
time(lun="烧肉饭",din="糖醋排骨，空心菜",ant="小米粥")

执行结果：
8点起床，收拾，吃小米粥
9点半坐车，去上班
12点午休时间，吃烧肉饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃糖醋排骨，空心菜 ,休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到

以上实例，使用关键字参数的好处，不用记得形参的位置

# 混合参数

可以把位置参数跟关键字参数混合着用，也就是说在调用函数的时候可以给出位置参数，也可以指定关键字函数

注意：在使用混合参数的时候，关键字参数必须在位置参数后面

不建议使用混合参数，因为如果使用混合参数，要先用位置参数用完后才能使用关键字参数，位置参数还要有顺序的不能说中间有个关键字参数，这样会报错

def time(ant,lun,din):
    print("8点起床，收拾，吃%s" % ant)
    print("9点半坐，去上班")
    print("12点午休时间，吃%s，午休" % lun)
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃%s ,休息" % din)
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
# time(lun="烧肉饭",din="糖醋排骨，空心菜",ant="小米粥")
time("豆浆油条",din="糖醋排骨，空心菜",lun="烧肉饭")

执行结果：
8点起床，收拾，吃豆浆油条
9点半坐，去上班
12点午休时间，吃烧肉饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃糖醋排骨，空心菜 ,休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到

# 函数的参数－形参

# 位置参数

位置参数，按照位置来赋值，系统默认使用的函数参数

def time(ant,lun,din):
    print("8点起床，收拾，吃%s" % ant)
    print("9点半坐车，去上班")
    print("12点午休时间，吃%s，午休" % lun)
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃%s ,休息" % din)
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
time("小米粥","烧肉饭","糖醋排骨，空心菜")

执行结果：
8点起床，收拾，吃小米粥
9点半坐车，去上班
12点午休时间，吃烧肉饭，午休
14点，上班时间
18点下班时间，收拾东西下班，坐车回家
18点半去集市买菜
19点到家煮饭
20点吃糖醋排骨，空心菜 ,休息
21点半洗澡准备回房间休息
22点到房间看会书
23点半睡觉时间到

# 默认值参数

在函数声明的时候，就可以给出函数参数的默认值，在调用的时候可以给出具体的值，也可以不给值，使用默认值

注意：必须先声明位置参数才能声明默认值参数

def time(lun,din,ant="豆浆油条"):
    print("8点起床，收拾，吃%s" % ant)
    print("9点半坐，去上班")
    print("12点午休时间，吃%s，午休" % lun)
    print("14点，上班时间")
    print("18点下班时间，收拾东西下班，坐车回家")
    print("18点半去集市买菜")
    print("19点到家煮饭")
    print("20点吃%s ,休息" % din)
    print("21点半洗澡准备回房间休息")
    print("22点到房间看会书")
    print("23点半睡觉时间到")
time(din="糖醋排骨，空心菜",lun="烧肉饭")

注意：千万要注意：需要先声明位置参数形参，才能声明默认值参数形参，不然会报错

← 16. 文件操作 18. 函数的进阶 →